//泛型上界
//语法：
/*class MyArray<T extends Number>{
    //这个时候就规定了传入的参数是Number或者是Number的子类，T就是Number或者其子类
    //此时就指定了传入的参数的T的一个界限
}*/

//泛型上界复杂示例：
//洗一个泛型类，令当中有一个方法，可以求数组元素的最大值
class Alg<T extends Comparable<T>>{//这个时候要实现Comparable接口
    /*public T[] array = (T[]) new Object[10];//这样写就是把Object类进行强制转化为T类型数组。

    public void setArray(int pos,T val) {
        array[pos] = val;
    }

    public T getArray(int pos) {
        return this.array[pos];
    }*/
    public T findMax(T[] array){
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
//            if (array[i] > max){//这个时候是直接比较不了的,两个都是自定义类型，因为这个时候我们没有鬼T到底是什么，所以就会保留原有类型，就是object类型
//                max = array[i];
//            }

            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}
class Person implements Comparable<Person> {
    @Override
    public int compareTo(Person o) {
        return 0;
    }
}

public class Test2 {
    public static void main1(String[] args) {
        Integer[] array = {1,2,3,4,45,5,6,8};
        Alg<Integer> alg = new Alg<>();
        int a = alg.findMax(array);
        System.out.println(a);

        Alg<Person> alg1 = new Alg<Person>();//Person不在alg这类的参数T的范围之内，所以就会报错

    }


    public static void main2(String[] args) {
        Alg2 alg2 = new Alg2();
        Integer[] array = new Integer[]{1,2,3,4,45,5,6,8};
        System.out.println(alg2.findMax(array));//这个时候编译器能自动推出它的所传的数据类型
        int ret = alg2.<Integer>findMax(array);//语法补全是前面具有<>的
    }

    public static void main(String[] args) {
        Integer[] array = new Integer[]{1,2,3,4,45,5,6,8};
        System.out.println(Alg3.findMax(array));
    }
}
//只要T类型实现了Comparable接口，那么以后的传的指定自定义类型一定要实现这个接口


//泛型方法
class Alg2{
    public<T extends Comparable> T findMax(T[] array){//保留了返回的值得类型，然后去像泛型类般去用<>，
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
//            if (array[i] > max){//这个时候是直接比较不了的,两个都是自定义类型，因为这个时候我们没有鬼T到底是什么，所以就会保留原有类型，就是object类型
//                max = array[i];
//            }

            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}

class Alg3{
    public static <T extends Comparable> T findMax(T[] array){//静态泛型方法
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}